package com.probox.common.entity.service.platfom.impl;

import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;

import java.util.*;
import java.util.stream.Collectors;

import com.probox.common.core.enums.DataStatus;
import com.probox.common.core.exception.BaseException;
import com.probox.common.core.utils.DateUtils;
import com.probox.common.core.utils.SecurityUtils;
import com.probox.common.core.utils.StringUtils;
import com.probox.common.entity.domain.platfom.vo.OptionsSelect;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.probox.common.entity.mapper.platfom.PlatformTemplateUrlMapper;
import com.probox.common.entity.domain.platfom.PlatformTemplateUrl;
import com.probox.common.entity.service.platfom.IPlatformTemplateUrlService;
import org.springframework.transaction.annotation.Transactional;

/**
 * 平台_模板链接配置Service业务层处理
 *
 *
 * @date 2021-06-15
 */
@Service
@Transactional
public class PlatformTemplateUrlServiceImpl extends ServiceImpl<PlatformTemplateUrlMapper, PlatformTemplateUrl> implements IPlatformTemplateUrlService {
    @Autowired
    private PlatformTemplateUrlMapper platformTemplateUrlMapper;


    /**
     * 查询平台_模板链接配置
     *
     * @param urlUid 平台_模板链接配置ID
     * @return 平台_模板链接配置
     */
    @Override
    public PlatformTemplateUrl selectPlatformTemplateUrlById(Long urlUid) {
        return this.getById(urlUid);
    }

    /**
     * 查询平台_模板链接配置列表
     *
     * @param platformTemplateUrl 平台_模板链接配置
     * @return 平台_模板链接配置
     */
    @Override
    public List<PlatformTemplateUrl> queryList(PlatformTemplateUrl platformTemplateUrl) {
        if (platformTemplateUrl.getPlatformUid() == null) {
            Long platformId = SecurityUtils.getPlatformId();
            if (platformId == null) {
                throw new BaseException("当前账号异常");
            }
            platformTemplateUrl.setPlatformUid(platformId);
        }
        QueryWrapper<PlatformTemplateUrl> queryWrapper = Wrappers.query();
        queryWrapper.ne("DATA_STATUS", DataStatus.delete.getKey());
        if (StringUtils.isNotEmpty(String.valueOf(platformTemplateUrl.getUrlValue())) && platformTemplateUrl.getUrlValue() != null) {
            queryWrapper.eq("URL_VALUE", platformTemplateUrl.getUrlValue());
        }
        if (StringUtils.isNotEmpty(String.valueOf(platformTemplateUrl.getDataStatus())) && platformTemplateUrl.getDataStatus() != null) {
            queryWrapper.eq("DATA_STATUS", platformTemplateUrl.getDataStatus());
        }

        if(ObjectUtil.isNotEmpty(platformTemplateUrl.getUrlType())){
            queryWrapper.eq("URL_TYPE",platformTemplateUrl.getUrlType());
        }

        if(ObjectUtil.isNotEmpty(platformTemplateUrl.getDataPriority())){
            queryWrapper.orderByAsc("DATA_PRIORITY");
        }

        return platformTemplateUrlMapper.selectList(queryWrapper);
    }
    @Override
    public boolean insertPlatformTemplateUrl(PlatformTemplateUrl platformTemplateUrl) {
        Long userId = SecurityUtils.getUserId();
        String username = SecurityUtils.getUsername();
        Date date = DateUtil.date();

        /**
         * 新增平台_模板链接配置
         *
         * @param platformTemplateUrl 平台_模板链接配置
         * @return 结果
         */

        platformTemplateUrl.setCreateUid(userId);
        platformTemplateUrl.setCreateName(username);
        platformTemplateUrl.setCreateTime(date);
        platformTemplateUrl.setUpdateUid(userId);
        platformTemplateUrl.setUpdateName(username);
        platformTemplateUrl.setUpdateTime(date);
        platformTemplateUrl.setDataStatus(DataStatus.valid.getKey());
        platformTemplateUrl.setPlatformUid(SecurityUtils.getPlatformId());
        return this.save(platformTemplateUrl);

    }

    /**
     * 修改平台_模板链接配置
     *
     * @param platformTemplateUrl 平台_模板链接配置
     * @return 结果
     */
    @Override
    public boolean updatePlatformTemplateUrl(PlatformTemplateUrl platformTemplateUrl) {
        Long userId = SecurityUtils.getUserId();
        String username = SecurityUtils.getUsername();
        Date date = DateUtil.date();
        platformTemplateUrl.setUpdateUid(userId);
        platformTemplateUrl.setUpdateName(username);
        platformTemplateUrl.setUpdateTime(date);
        return this.updateById(platformTemplateUrl);
    }

    /**
     * 批量删除平台_模板链接配置
     *
     * @param urlUids 需要删除的平台_模板链接配置ID
     * @return 结果
     */
    @Override
    public boolean deletePlatformTemplateUrlByIds(Long[] urlUids) {
        UpdateWrapper<PlatformTemplateUrl> updateWrapper = new UpdateWrapper<>();
        updateWrapper.set("DATA_STATUS", DataStatus.delete.getKey());
        updateWrapper.set("UPDATE_UID", SecurityUtils.getUserId());
        updateWrapper.set("UPDATE_NAME", SecurityUtils.getUsername());
        updateWrapper.set("UPDATE_TIME", DateUtil.date());
        updateWrapper.in("URL_UID", urlUids);
        return  this.update(updateWrapper);
    }


    /**
     * 获取链接的级联
     *
     * @return
     */
    @Override
    public List<OptionsSelect> selectOptionList() {
        List<OptionsSelect> collect = null;

        // String key = CachePrefix.PRODUCT_CATEGORY_CASCADER+SecurityUtils.getPlatformId();
        //collect = redisService.getCacheList(key);
        //if(collect == null){
        PlatformTemplateUrl platformTemplateUrl = new PlatformTemplateUrl();
        platformTemplateUrl.setDataStatus(DataStatus.valid.getKey());
        platformTemplateUrl.setDataPriority(1L);
        platformTemplateUrl.setPlatformUid(1L);
        List<PlatformTemplateUrl> list = this.queryList(platformTemplateUrl);
        List<PlatformTemplateUrl> returnList = new ArrayList<PlatformTemplateUrl>();
        List<Long> tempList = new ArrayList<Long>();
        for (PlatformTemplateUrl url : list) {
            tempList.add(url.getUrlUid());
        }
        for (Iterator<PlatformTemplateUrl> iterator = list.iterator(); iterator.hasNext(); ) {
            PlatformTemplateUrl url = (PlatformTemplateUrl) iterator.next();
            // 如果是顶级节点, 遍历该父节点的所有子节点
            if (!tempList.contains(url.getUrlPuid())) {
                recursionFn(list, url);
                returnList.add(url);
            }
        }
        if (returnList.isEmpty()) {
            returnList = list;
        }
        collect = returnList.stream().map(OptionsSelect::new).collect(Collectors.toList());
        //if(ObjectUtil.isNotEmpty(collect)) redisService.setCacheList(key, collect);
        // }
        return collect;
    }

    /**
     * 递归列表
     *
     * @param list
     * @param t
     */
    private void recursionFn(List<PlatformTemplateUrl> list, PlatformTemplateUrl t) {
        // 得到子节点列表
        List<PlatformTemplateUrl> childList = getChildList(list, t);
        t.setChildren(childList);
        for (PlatformTemplateUrl tChild : childList) {
            if (hasChild(list, tChild)) {
                recursionFn(list, tChild);
            }
        }
    }

    /**
     * 得到子节点列表
     */
    private List<PlatformTemplateUrl> getChildList(List<PlatformTemplateUrl> list, PlatformTemplateUrl t) {
        List<PlatformTemplateUrl> tlist = new ArrayList<PlatformTemplateUrl>();
        Iterator<PlatformTemplateUrl> it = list.iterator();
        while (it.hasNext()) {
            PlatformTemplateUrl n = (PlatformTemplateUrl) it.next();
            if (n.getUrlPuid().longValue() == t.getUrlUid().longValue()) {
                tlist.add(n);
            }
        }
        return tlist;
    }

    private boolean hasChild(List<PlatformTemplateUrl> list, PlatformTemplateUrl t) {
        return getChildList(list, t).size() > 0 ? true : false;
    }

}
